// 配置文件加载器
import systemConfig from '../../../config/system.config.json';

// 默认系统配置常量
const DEFAULT_SYSTEM_CONFIG = {
  systemName: '加盟商服务平台',
  logoSrc: '/favicon.ico',
  logoAlt: '系统Logo',
  defaultUserName: '用户名',
  defaultUserAvatar: '/favicon.ico',
  defaultUserOrganization: '默认组织'
};

// 默认登录配置常量
const DEFAULT_LOGIN_CONFIG = {
  systemTitle: '充电服务管理平台',
  logoSrc: '/favicon.ico',
  leftDecorationSrc: '/img/login_bg.png',
  copyright: 'Copyright © 2014 - 2025 T新能源股份有限公司'
};

/**
 * 将配置文件转换为与原始mock数据兼容的格式
 * @returns {Object} 转换后的菜单数据
 */
export function loadMenuFromConfig() {
  try {
    // 校验配置格式
    if (!systemConfig) {
      return {
        code: 500,
        message: '配置文件未找到或为空',
        data: null
      };
    }

    if (!systemConfig.functionGroups || !Array.isArray(systemConfig.functionGroups)) {
      return {
        code: 500,
        message: '配置文件格式错误：functionGroups 必须是数组',
        data: null
      };
    }

    if (systemConfig.functionGroups.length === 0) {
      return {
        code: 500,
        message: '配置文件格式错误：functionGroups 不能为空',
        data: null
      };
    }

    // 校验每个功能组的格式
    for (let i = 0; i < systemConfig.functionGroups.length; i++) {
      const group = systemConfig.functionGroups[i];
      
      if (!group.groupName || typeof group.groupName !== 'string') {
        return {
          code: 500,
          message: `配置文件格式错误：第${i + 1}个功能组的 groupName 必须是非空字符串`,
          data: null
        };
      }

      if (!group.functions || !Array.isArray(group.functions)) {
        return {
          code: 500,
          message: `配置文件格式错误：第${i + 1}个功能组的 functions 必须是数组`,
          data: null
        };
      }

      // 校验每个功能的格式
      for (let j = 0; j < group.functions.length; j++) {
        const func = group.functions[j];
        
        if (!func.functionName || typeof func.functionName !== 'string') {
          return {
            code: 500,
            message: `配置文件格式错误：第${i + 1}个功能组第${j + 1}个功能的 functionName 必须是非空字符串`,
            data: null
          };
        }

        if (!func.navigateUrl || typeof func.navigateUrl !== 'string') {
          return {
            code: 500,
            message: `配置文件格式错误：第${i + 1}个功能组第${j + 1}个功能的 navigateUrl 必须是非空字符串`,
            data: null
          };
        }
      }
    }

    const { functionGroups } = systemConfig;
    
    // 转换功能组数据
    const childGroups = functionGroups.map((group, groupIndex) => {
    // 转换功能数据
    const functions = group.functions.map((func, funcIndex) => ({
      Name: func.functionName,
      NameInitials: func.functionName,
      Code: `301-005-000-${String(groupIndex + 1).padStart(3, '0')}-${String(funcIndex + 1).padStart(3, '0')}`,
      FunctionType: 0,
      NavigateUrl: func.navigateUrl,
      Description: "",
      Icon: null,
      IconColor: null,
      RouterInfo: null,
      ApplicationSystemID: null,
      FunctionGroupID: null,
      Type: "4",
      ApplicationURL: null,
      AppID: null,
      MID: null,
      MaxWin: 0,
      EndpointDisplayConfig: 0,
      ID: `func-${groupIndex}-${funcIndex}`
    }));
    
    return {
      Name: group.groupName,
      NameInitials: group.groupName,
      Code: `301-005-000-${String(groupIndex + 1).padStart(3, '0')}`,
      ParentFuncGroupID: null,
      Layer: 2,
      Img: "",
      NavigateUrl: "",
      Path: null,
      ChildGroup: [],
      Functions: functions,
      ID: `group-${groupIndex}`
    };
  });
  
    // 返回完整的菜单数据结构
    return {
      code: 200,
      message: '获取成功',
      data: {
        ApplicationID: "64b4e441-82d7-4314-b25d-6efaefc61dcb",
        ApplicationName: systemConfig.ApplicationName,
        AppFullName: systemConfig.ApplicationName,
        ApplicationIcon: "",
        IsDisabled: 0,
        Comments: "",
        ApplicationURL: "",
        DeleteMark: 0,
        AppID: "MenuSystem",
        SortCode: 0,
        NodeType: 0,
        Type: "1",
        ChildGroup: childGroups
      }
    };
  } catch (error) {
    console.error('配置文件处理异常:', error);
    return {
      code: 500,
      message: `配置文件处理异常: ${error.message}`,
      data: null
    };
  }
}


/**
 * 获取系统配置
 * @returns {Object} 系统配置对象
 */
export function getSystemConfig() {
  try {
    if (!systemConfig || !systemConfig.systemConfig) {
      return DEFAULT_SYSTEM_CONFIG;
    }
    
    // 创建系统配置对象
    const config = { ...systemConfig.systemConfig };
    
    // 从userProfileConfig.userInfo中获取用户名和头像
    if (systemConfig.userProfileConfig && systemConfig.userProfileConfig.userInfo) {
      const userInfo = systemConfig.userProfileConfig.userInfo;
      
      // 使用userInfo中的UserName作为defaultUserName
      if (userInfo.UserName) {
        config.defaultUserName = userInfo.UserName;
      }
      
      // 使用userInfo中的Avatar作为defaultUserAvatar
      if (userInfo.Avatar) {
        config.defaultUserAvatar = userInfo.Avatar;
      }
      
      // 根据CompanyName和DepartmentName设置defaultUserOrganization
      if (userInfo.CompanyName && userInfo.DepartmentName) {
        config.defaultUserOrganization = `${userInfo.CompanyName}-${userInfo.DepartmentName}`;
      } else if (userInfo.CompanyName) {
        config.defaultUserOrganization = userInfo.CompanyName;
      } else if (userInfo.DepartmentName) {
        config.defaultUserOrganization = userInfo.DepartmentName;
      }
    }
    
    return config;
  } catch (error) {
    console.error('获取系统配置异常:', error);
    return DEFAULT_SYSTEM_CONFIG;
  }
}

/**
 * 获取是否使用配置文件的标志
 * @returns {boolean} 是否使用配置文件
 */
export function getUseConfigFileFlag() {
  try {
    if (!systemConfig || systemConfig.useConfigFile === undefined) {
      return true; // 默认使用配置文件
    }
    return systemConfig.useConfigFile;
  } catch (error) {
    console.error('获取配置文件标志异常:', error);
    return true; // 出错时默认使用配置文件
  }
}

/**
 * 获取登录页面配置
 * @returns {Object} 登录配置对象
 */
export function getLoginConfig() {
  try {
    if (!systemConfig || !systemConfig.loginConfig) {
      return DEFAULT_LOGIN_CONFIG;
    }
    return systemConfig.loginConfig;
  } catch (error) {
    console.error('获取登录配置异常:', error);
    return DEFAULT_LOGIN_CONFIG;
  }
}

/**
 * 验证配置文件格式
 * @returns {Object} 验证结果
 */
export function validateConfig() {
  const errors = [];
  const warnings = [];
  
  // 检查功能组
  if (!Array.isArray(systemConfig.functionGroups)) {
    errors.push('functionGroups 必须是数组');
  } else {
    systemConfig.functionGroups.forEach((group, groupIndex) => {
      if (!group.groupName) {
        errors.push(`功能组 ${groupIndex} 缺少 groupName`);
      }
      if (!Array.isArray(group.functions)) {
        errors.push(`功能组 ${groupIndex} 的 functions 必须是数组`);
      } else {
        group.functions.forEach((func, funcIndex) => {
          if (!func.functionName) {
            errors.push(`功能组 ${groupIndex} 的功能 ${funcIndex} 缺少 functionName`);
          }
          if (!func.navigateUrl) {
            errors.push(`功能组 ${groupIndex} 的功能 ${funcIndex} 缺少 navigateUrl`);
          }
        });
      }
    });
  }
  
  return {
    isValid: errors.length === 0,
    errors,
    warnings
  };
}

// 默认导出配置加载函数
export default loadMenuFromConfig;